home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / util / primitives / funcs.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  15.3 KB  |  555 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from __future__ import with_statement
  5. from functional import ObjectList
  6. from refs import stupidref, better_ref
  7. from collections import defaultdict
  8. from error_handling import traceguard
  9. from operator import attrgetter
  10. import functools
  11. import logging
  12. import operator
  13. import pprint
  14. import sys
  15. import traceback
  16.  
  17. try:
  18.     sentinel
  19. except NameError:
  20.     sentinel = object()
  21.  
  22. log = logging.getLogger('util.primitives.funcs')
  23.  
  24. def get(obj, key, default = sentinel):
  25.     
  26.     try:
  27.         return obj[key]
  28.     except (IndexError, KeyError):
  29.         if default is sentinel:
  30.             raise 
  31.         else:
  32.             return default
  33.     except TypeError:
  34.         
  35.         try:
  36.             return getattr(obj, key)
  37.         except AttributeError:
  38.             if default is sentinel:
  39.                 raise 
  40.             else:
  41.                 return default
  42.         except:
  43.             default is sentinel
  44.         
  45.  
  46.         None<EXCEPTION MATCH>AttributeError
  47.  
  48.  
  49.  
  50. def ischeck(f):
  51.     
  52.     def checker(v):
  53.         
  54.         try:
  55.             r = f(v)
  56.         except:
  57.             return False
  58.  
  59.         if type(r) is bool:
  60.             return r
  61.         else:
  62.             return True
  63.  
  64.     return checker
  65.  
  66.  
  67. def itercheck(x, exclude = (basestring,)):
  68.     
  69.     try:
  70.         iter(x)
  71.     except:
  72.         return False
  73.  
  74.     if not isinstance(x, exclude):
  75.         return True
  76.     else:
  77.         return False
  78.  
  79. isint = ischeck(int)
  80. isiterable = ischeck(itercheck)
  81. isnumber = ischeck(float)
  82.  
  83. def make_first(seq, item):
  84.     
  85.     try:
  86.         idx = seq.index(item)
  87.         seq.pop(idx)
  88.     except ValueError:
  89.         pass
  90.  
  91.     seq.insert(0, item)
  92.  
  93.  
  94. def do(seq_or_func, seq = None):
  95.     if seq is None:
  96.         for x in seq_or_func:
  97.             pass
  98.         
  99.     else:
  100.         for x in seq:
  101.             seq_or_func(x)
  102.         
  103.  
  104.  
  105. def find(seq, item):
  106.     
  107.     try:
  108.         return seq.index(item)
  109.     except ValueError:
  110.         return -1
  111.  
  112.  
  113.  
  114. def groupby(seq, key = (lambda x: x)):
  115.     res = defaultdict(list)
  116.     for item in seq:
  117.         res[key(item)].append(item)
  118.     
  119.     for k in res:
  120.         yield (k, res[k])
  121.     
  122.  
  123.  
  124. class Delegate(ObjectList):
  125.     VETO = object()
  126.     
  127.     def __init__(self, iterable = [], ignore_exceptions = None, collect_values = False):
  128.         list.__init__(self, iterable)
  129.         self.__dict__['collect_values'] = collect_values
  130.         None(object.__setattr__, self, 'ignore_exceptions' if ignore_exceptions is not None else tuple())
  131.  
  132.     
  133.     def __iadd__(self, f):
  134.         if isinstance(f, list):
  135.             for thing in f:
  136.                 self.__iadd__(thing)
  137.             
  138.         else:
  139.             self.append(f)
  140.         return self
  141.  
  142.     
  143.     def __isub__(self, f):
  144.         if not isiterable(f):
  145.             f = (f,)
  146.         
  147.         for x in f:
  148.             self.remove(x)
  149.         
  150.         return self
  151.  
  152.     
  153.     def __ipow__(self, d):
  154.         self(**d)
  155.         return self
  156.  
  157.     
  158.     def __imul__(self, a):
  159.         self(*a)
  160.         return self
  161.  
  162.     
  163.     def __idiv__(self, tup):
  164.         (a, k) = tup
  165.         self(*a, **k)
  166.         return self
  167.  
  168.     
  169.     def __call__(self, *a, **k):
  170.         result = [
  171.             None]
  172.         for call in self:
  173.             
  174.             try:
  175.                 result.append(call(*a, **k))
  176.             except self.ignore_exceptions:
  177.                 self.remove(call)
  178.             except Exception:
  179.                 traceback.print_exc()
  180.  
  181.             if result[-1] is self.VETO:
  182.                 break
  183.             
  184.             if not self.collect_values:
  185.                 result = result[-1:]
  186.                 continue
  187.         
  188.         if self.collect_values:
  189.             result.pop(0)
  190.         else:
  191.             result = result[-1]
  192.         return result
  193.  
  194.     
  195.     def call_and_clear(self):
  196.         result = self()
  197.         self[:] = []
  198.         return result
  199.  
  200.     
  201.     def __repr__(self):
  202.         funcinfo = funcinfo
  203.         import util
  204.         return '<%s: [%s]>' % (type(self).__name__, (', '.join,)((lambda .0: for f in .0:
  205. funcinfo(f))(self)))
  206.  
  207.     
  208.     def add_unique(self, cb):
  209.         if cb not in self:
  210.             self.append(cb)
  211.         
  212.  
  213.     
  214.     def remove_maybe(self, cb):
  215.         if cb in self:
  216.             self.remove(cb)
  217.         
  218.  
  219.  
  220. objset = object.__setattr__
  221.  
  222. class PausableDelegate(Delegate):
  223.     
  224.     def __init__(self):
  225.         Delegate.__init__(self)
  226.         objset(self, 'paused', False)
  227.  
  228.     
  229.     def __call__(self, *a, **k):
  230.         if self.paused:
  231.             (None, None, self.paused_calls.append)((lambda : Delegate.__call__(self, *a, **k)))
  232.             return None
  233.         else:
  234.             return Delegate.__call__(self, *a, **k)
  235.  
  236.     
  237.     def pause(self):
  238.         if not self.paused:
  239.             objset(self, 'paused', True)
  240.             objset(self, 'paused_calls', [])
  241.             return True
  242.         
  243.         return False
  244.  
  245.     
  246.     def unpause(self):
  247.         if self.paused:
  248.             objset(self, 'paused', False)
  249.             if self.paused_calls:
  250.                 for call in self.paused_calls:
  251.                     traceguard.__enter__()
  252.                     
  253.                     try:
  254.                         call()
  255.                     finally:
  256.                         pass
  257.  
  258.                 
  259.                 del self.paused_calls[:]
  260.             
  261.             return True
  262.         
  263.         return False
  264.  
  265.  
  266.  
  267. class WeakDelegate(object):
  268.     
  269.     def __init__(self):
  270.         self.cbs = []
  271.  
  272.     
  273.     def append(self, cb, obj = None):
  274.         self.cbs.append(better_ref(cb, obj = obj))
  275.  
  276.     
  277.     def __iadd__(self, cb):
  278.         self.cbs.append(better_ref(cb))
  279.         return self
  280.  
  281.     
  282.     def __isub__(self, cb):
  283.         new_cbs = []
  284.         for cbref in self.cbs:
  285.             callback = cbref()
  286.             if cb is not callback:
  287.                 new_cbs.append(cb)
  288.                 continue
  289.         
  290.         self.cbs = new_cbs
  291.         return self
  292.  
  293.     
  294.     def __call__(self, *a, **k):
  295.         new_cbs = []
  296.         cbs = self.cbs[:]
  297.         self.cbs[:] = []
  298.         for cbref in cbs:
  299.             callback = cbref()
  300.             if callback is not None:
  301.                 new_cbs.append(cbref)
  302.                 
  303.                 try:
  304.                     callback(*a, **k)
  305.                 except Exception:
  306.                     traceback.print_exc()
  307.                 except:
  308.                     None<EXCEPTION MATCH>Exception
  309.                 
  310.  
  311.             None<EXCEPTION MATCH>Exception
  312.         
  313.         self.cbs[:] = new_cbs
  314.  
  315.  
  316.  
  317. def autoassign(self, locals):
  318.     for key, value in locals.iteritems():
  319.         if key == 'self':
  320.             continue
  321.         
  322.         setattr(self, key, value)
  323.     
  324.  
  325.  
  326. def flatten(seq):
  327.     lst = []
  328.     for el in seq:
  329.         if isinstance(el, (list, tuple)):
  330.             lst.extend(flatten(el))
  331.             continue
  332.         lst.append(el)
  333.     
  334.     return lst
  335.  
  336.  
  337. def dictargs(**argmap):
  338.     
  339.     def decorator(func):
  340.         
  341.         def newf(self, response):
  342.             
  343.             try:
  344.                 args = _[1]
  345.             except KeyError:
  346.                 print >>sys.stderr, 'Error matching argument for', func.__name__
  347.                 raise 
  348.  
  349.             return func(self, *args)
  350.  
  351.         newf = (None, functools.wraps(func))(newf)
  352.         return newf
  353.  
  354.     return decorator
  355.  
  356.  
  357. def dictargcall(func, argdict, argmapping):
  358.     argdict = argdict.copy()
  359.     args = []
  360.     kwargs = { }
  361.     code = func.func_code
  362.     argcount = code.co_argcount
  363.     argnames = code.co_varnames[:argcount]
  364.     if not func.func_defaults:
  365.         pass
  366.     defaults = ()
  367.     _takes_args = bool(code.co_flags & 4)
  368.     takes_kwargs = bool(code.co_flags & 8)
  369.     if argnames and argnames[0] == 'self':
  370.         argnames = argnames[1:]
  371.         argcount -= 1
  372.     
  373.     for argname in argnames[:argcount - len(defaults)]:
  374.         if argname not in argmapping:
  375.             raise ValueError('required argument %s is not in mapping\ngiven mapping: %s' % (argname, pprint.pformat(argmapping)))
  376.         
  377.         real_name = argmapping[argname]
  378.         if real_name not in argdict:
  379.             raise ValueError('required argument "%s" (%s) is not in argument dictionary\ngiven arguments: %s' % (argname, real_name, pprint.pformat(argdict)))
  380.         
  381.         args.append(argdict[real_name])
  382.         del argdict[real_name]
  383.     
  384.     default_index = 0
  385.     for argname in argnames[argcount - len(defaults):]:
  386.         if argname not in argmapping or argmapping[argname] not in argdict:
  387.             args.append(defaults[default_index])
  388.         else:
  389.             args.append(argdict[argmapping[argname]])
  390.             del argdict[argmapping[argname]]
  391.         default_index += 1
  392.     
  393.     if takes_kwargs:
  394.         for k, v in argdict.iteritems():
  395.             if k in argmapping:
  396.                 kwargs[argmapping[k]] = v
  397.                 continue
  398.             kwargs[str(k)] = v
  399.         
  400.     
  401.     if not takes_kwargs:
  402.         return func(*args)
  403.     else:
  404.         return func(*args, **kwargs)
  405.  
  406.  
  407. def funcToMethod(func, clas, method_name = None):
  408.     func.im_class = clas
  409.     func.im_func = func
  410.     func.im_self = None
  411.     if not method_name:
  412.         method_name = func.__name__
  413.     
  414.     clas.__dict__[method_name] = func
  415.  
  416.  
  417. def attach_method(obj, func, name = None):
  418.     if not name:
  419.         pass
  420.     name = func.__name__
  421.     cls = obj.__class__
  422.     cls.temp_foo = func
  423.     obj.__setattr__(name, cls.temp_foo)
  424.     del cls.temp_foo
  425.  
  426.  
  427. class InheritableProperty(object):
  428.     
  429.     def __init__(self, fget = None, fset = None, fdel = None, doc = None):
  430.         self.fget = fget
  431.         self.fset = fset
  432.         self.fdel = fdel
  433.         self.__doc__ = doc
  434.  
  435.     
  436.     def __get__(self, obj, objtype = None):
  437.         if obj is None:
  438.             return self
  439.         
  440.         if callable(self.fget):
  441.             return self.fget(obj)
  442.         
  443.         if isinstance(self.fget, basestring):
  444.             return getattr(obj, self.fget)()
  445.         
  446.         raise AttributeError('unreadable attribute')
  447.  
  448.     
  449.     def __set__(self, obj, value):
  450.         if callable(self.fset):
  451.             return self.fset(obj, value)
  452.         
  453.         if isinstance(self.fset, basestring):
  454.             return getattr(obj, self.fset)(value)
  455.         
  456.         raise AttributeError("can't set attribute")
  457.  
  458.     
  459.     def __delete__(self, obj):
  460.         if callable(self.fdel):
  461.             return self.fdel(obj)
  462.         
  463.         if isinstance(self.fdel, basestring):
  464.             return getattr(obj, self.fdel)()
  465.         
  466.         raise AttributeError("can't delete attribute")
  467.  
  468.  
  469. iproperty = InheritableProperty
  470.  
  471. def gen_sequence(func):
  472.     cannotcompile = cannotcompile
  473.     import util.introspect
  474.     
  475.     def wrapper(*args, **kwargs):
  476.         gen = func(*args, **kwargs)
  477.         val = gen.next()
  478.         
  479.         try:
  480.             gen.send(stupidref(gen))
  481.         except StopIteration:
  482.             pass
  483.  
  484.         return val
  485.  
  486.     wrapper = cannotcompile((functools.wraps(func),)(wrapper))
  487.     return wrapper
  488.  
  489.  
  490. def removedupes(seq, key = (lambda x: x)):
  491.     s = set()
  492.     uniqueseq = []
  493.     for elem in seq:
  494.         if key(elem) not in s:
  495.             uniqueseq.append(elem)
  496.             s.add(key(elem))
  497.             continue
  498.     
  499.     return uniqueseq
  500.  
  501.  
  502. def lispify(*args):
  503.     
  504.     try:
  505.         iter(args[0])
  506.     except:
  507.         pass
  508.  
  509.     args = args[0]
  510.     return reduce((lambda x, y: (lambda : x(y(*a, **k)))
  511. ), args)
  512.  
  513.  
  514. class CallCounter(object):
  515.     
  516.     def __init__(self, trigger, func, *args, **kwargs):
  517.         self._count = -1
  518.         self._trigger = trigger
  519.         self._func = func
  520.         self._args = args
  521.         self._kwargs = kwargs
  522.         self()
  523.  
  524.     
  525.     def __call__(self):
  526.         self._count += 1
  527.         if self._count == self._trigger:
  528.             self._func(*self._args, **self._kwargs)
  529.         
  530.  
  531.     
  532.     def func_code(self):
  533.         return self._func.func_code
  534.  
  535.     func_code = property(func_code)
  536.  
  537.  
  538. def readonly(attr):
  539.     return property(attrgetter(attr))
  540.  
  541.  
  542. def takemany(n, iterable):
  543.     while n > 0:
  544.         yield iterable.next()
  545.         n -= 1
  546.  
  547.  
  548. def boolify(s):
  549.     return s.lower() in ('yes', 'true', '1')
  550.  
  551. if __name__ == '__main__':
  552.     import doctest
  553.     doctest.testmod(verbose = True)
  554.  
  555.